suggestion: Consider improving error handling in create_world function

While the function catches and logs exceptions, it might be beneficial to add more specific error handling for different types of request exceptions. This could help in diagnosing and addressing specific issues more effectively.

def create_world(self, is_video_create, data):
    try:
        # Existing function logic here
    except requests.exceptions.ConnectionError as e:
        logger.error(f"Connection error: {e}")
        raise self.retry(exc=e)
    except requests.exceptions.Timeout as e:
        logger.error(f"Request timed out: {e}")
        raise self.retry(exc=e)
    except requests.exceptions.RequestException as e:
        logger.error(f"Request failed: {e}")
        raise self.retry(exc=e)

🚨 suggestion (security): Reconsider token generation method for improved security

The current token generation method uses a simple SHA256 hash of the email, which might not be sufficiently secure. Consider using a more robust method, such as a cryptographically secure random number generator, to create these tokens.

import secrets

def generate_token(request):
    """
    Generate secure token for video system
    """
    return secrets.token_urlsafe(32)

suggestion (bug_risk): Implement safeguard against duplicate world creation

The create_world task is called in both the done and form_valid methods. Consider adding a check to prevent duplicate world creation if a world already exists for this event.

issue (complexity): Consider extracting video creation logic into separate methods for improved modularity.

The done and form_valid methods have become more complex with the addition of video creation logic. To improve readability and maintainability, consider extracting the video creation related code into a separate method. This will make the code more modular while maintaining the new functionality. Here's an example of how you could refactor the form_valid method:

class EventUpdate(DecoupleMixin, EventSettingsViewMixin, EventPermissionRequiredMixin, MetaDataEditorMixin, UpdateView):
    # ... existing code ...

    @transaction.atomic
    def form_valid(self, form):
        self._save_decoupled(self.sform)
        self.sform.save()

        tickets.invalidate_cache.apply_async(kwargs={'event': self.request.event.pk})

        self._handle_video_creation(form)

        messages.success(self.request, _('Your changes have been saved.'))
        return super().form_valid(form)

    def _handle_video_creation(self, form):
        if check_create_permission(self.request):
            form.instance.is_video_create = form.cleaned_data.get('is_video_create')
        elif not check_create_permission(self.request) and form.cleaned_data.get('is_video_create'):
            form.instance.is_video_create = True
        else:
            form.instance.is_video_create = False

        data = dict(id=form.cleaned_data.get('slug'), title=form.cleaned_data.get('name').data,
                    timezone=self.sform.cleaned_data.get('timezone'), locale=self.sform.cleaned_data.get('locale'),
                    has_permission=check_create_permission(self.request), token=generate_token(self.request))

        create_world.delay(is_video_create=form.cleaned_data.get('is_video_create'), data=data)

This refactoring extracts the video creation logic into a separate _handle_video_creation method, making the form_valid method cleaner and easier to understand. You can apply a similar approach to the done method in the wizard view. This change improves the separation of concerns without introducing unnecessary complexity.

Why space after "="?

The uid_token seems not to carry any info for client side to extract. If so, please use a short method with secrets module to generate it, as @sourcery-ai suggested.

Why do you still have to create uid_token in a very complex way?

Why do you still have to create uid_token in a very complex way?